#define _CRT_SECURE_NO_WARNINGS

//


#include <iostream>

using namespace std;

class Rectangle
{

private:

    int length, width;//成员变量表示长方形的长和宽
    static int TotalNum, TotalArea, TotalPerimeter;//静态成员变量

public:

    //constructor

    Rectangle(int l = 2, int w = 1)//第一个参数传递给length，第二个传递给width，添加对静态成员变量的更新
    {
        length = l;
        width = w;
        TotalNum++;
        TotalArea += (w * l);
        TotalPerimeter += (2 * w + 2 * l);
    }

    Rectangle(const Rectangle& r)//复制构造函数，添加对静态成员变量的更新
    {
        int w = width;
        int l = length;
        this->width = r.width;
        this->length = r.length;
        TotalNum++;
        TotalArea += (w * l);
        TotalPerimeter += (2 * w + 2 * l);
    }

    //getter 读取属性值
    int getLength() const { return length; }
    int getWidth() const { return width; }

    //setter 修改属性值
    void setLength(int l) { length = l; }
    void setWidth(int w) { width = w; }

    //计算面积
    int getArea() const { return (width * length); }

    //计算周长

    int getPerimeter() const { return(2 * width + 2 * length); }

    Rectangle operator+(const Rectangle& r)const//加法
    {
        Rectangle ret = *this;
        ret.setLength(this->getLength() + r.getLength());
        ret.setWidth(this->getWidth() + r.getWidth());
        return ret;
    }
    Rectangle& operator++()//前置
    {
        this->setLength(this->getLength() + 1);
        this->setWidth(this->getWidth() + 1);
        return *this;
    }
    Rectangle operator++(int)//后置
    {
        Rectangle temp = *this;
        this->setLength(this->getLength() + 1);
        this->setWidth(this->getWidth() -+ 1);
        return temp;
    }
    bool operator>(const Rectangle& r)//根据周长判断大小
    {
        if (this->getPerimeter() > r.getPerimeter())
        {
            return true;
        }
        return false;
    }

    //输出函数，如果当前长方形长和宽分别为2和1，则输出(l:2,w:1)

    void show()
    {
        cout << "(" << "l:" << length << ",w:" << width << ")";
    }

    ~Rectangle()//析构函数，添加对静态成员变量的更新
    {
        int w = width;
        int l = length;
        TotalNum--;
        TotalArea -= (w * l);
        TotalPerimeter -= (2 * w + 2 * l);
    }

    //静态成员函数
    static int getTotalNum() { return TotalNum; }
    static int getTotalArea() { return TotalArea; }
    static int getTotalPerimeter() { return TotalPerimeter; }

};


bool operator==(const Rectangle& r1, const Rectangle& r2)//长和宽分别相等
{
    if (r1.getLength() == r2.getLength() && r1.getWidth() == r2.getWidth())
    {
        return true;
    }
    return false;
}

Rectangle& operator--(Rectangle& r)//前置
{
    r.setLength(r.getLength() - 1);
    r.setWidth(r.getWidth() - 1);
    return r;
}

Rectangle operator--(Rectangle& r, int)//后置
{
    Rectangle temp = r;
    r.setLength(r.getLength() - 1);
    r.setWidth(r.getWidth() - 1);
    return temp;
}

//静态成员变量初始化
int Rectangle::TotalNum = 0;
int Rectangle::TotalArea = 0;
int Rectangle::TotalPerimeter = 0;

int main()
{

    int len1, wid1, len2, wid2;
    cin >> len1 >> wid1 >> len2 >> wid2;
    Rectangle r1(len1, wid1), r2(len2, wid2);

    //加法运算符
    r1.show();
    cout << "+";
    r2.show();
    cout << "=";
    (r1 + r2).show();
    cout << endl;

    //>运算符
    r1.show();
    cout << ">";
    r2.show();
    cout << "=" << (r1 > r2);
    cout << endl;

    //==运算符
    r1.show();
    cout << "==";
    r2.show();
    cout << "=" << (r1 == r2);
    cout << endl;

    //++，--运算符
    cout << "++";
    r1.show();
    cout << "=";
    (++r1).show();
    cout << endl;

    r1.show();
    cout << "--";
    cout << "=";
    (r1--).show();
    cout << endl;

    return 0;
}

//#include <iostream>
//
//using namespace std;

//template <typename T1>
//void Swap(T1& a, T1& b)
//{
//	T1 c = a;
//	a = b;
//	b = c;
//}
//
//template <typename T1>
//void Swap(T1& a, T1& b)
//{
//	T1 c = a;
//	a = b;
//	b = c;
//}
//
//template <typename T1, int n>
//T1 Add(T1& a, T1& b)
//{
//	return a + b;
//}
//
//int main()
//{
//	int a = 0, b = 1;
//	Swap(a, b);
//
//
//	return 0;
//}


////template <class T>
//template <typename T = int> void Print(T t)
//{
//    std::cout << "Template: " << t << std::endl;
//}
//
//void Print(int t)
//{
//    std::cout << "Non-template: " << t << std::endl;
//}
//
//int main()
//{
//    Print(42);  // 编译器会选择调用 `Print(int)`
//    Print<int>(42);
//
//    Print("Hello");  // 编译器会选择调用模板版本 `Print(const char*)`
//
//    // 当我们给出不明确的类型时，编译器无法推导
//    Print(3.14);  // 错误: 编译器无法决定是调用模板 `Print(double)` 还是其他重载
//    Print(3.14f);
//
//    return 0;
//}

//#include <iostream>

//using namespace std;

////template <typename T1 = int>// 支持声明和定义分离, 但是模板函数的声明前也需要有 template
////void Swap(T1& a, T1& b);// 模板函数声明
//
//template <typename T1 = int>
////template <class T1>    // 也可以使用 class 替换 typename
//void Swap(T1& a, T1& b)// 模板函数定义
//{// 这个函数模板可以实现两个同类型变量的交换
//    T1 c = a;
//    a = b;
//    b = c;
//}
//
//template <typename T1> T1 Add(T1 a, T1 b)// 也可以写在同一行
//{// 但是 template 和模板函数的声明 + 定义个数一定是相等的
//    return a + b;
//}
//#include "test.h"
//
//int main()
//{
//    Test();
//
//    return 0;
//}